﻿#include<iostream>
#include<algorithm>
using namespace std;


//编译器变量搜索顺序
//局部变量
//全局变量
//展开的命名空间



////不同文件或者一个文件同一命名会合并
//
//
////命名空间
//namespace t
//{
//	int a = 10;
//	int b = 20;
//	//镶套
//	int add(int x, int y)
//	{
//		return x + y;
//	}
//}
//
////镶套空间命名
//namespace r
//{
//	namespace f
//	{
//
//	}
//	int a = 10;
//	int b = 20;
//}
//int a = 1;
//
////开展全部命名空间
////using namespace t;
//
////开展特定命名空间变量
//using t::b;
//
//
////缺省参数 
////(1)有传参就代替;
////(2)声明和定义只能有一个有缺省参数，最要在声明
//
//
////全缺省
//int add(int x = 10, int y = 10)
//{
//	return x + y;
//}
//
////半缺省 ,只能从右向左
//int dd(int x, int y=10 )
//{
//	return x + y;
//}

//void initialize(int capacity = 4) //不知道空间多大时，默认为4
//{
//	//用初始化的容量去申请空间
//	int* a = (int*)malloc(sizeof(int) * capacity);
//}
//
////声明
//int add(int x = 10, int y = 10);
//
////定义
//int add(int x = 10,int y = 10)
//{
//	return x + y;
//}
//
//int main()
//{
//	add();
//	return 0;
//}

//函数重载

////参数类型不同
//int add(int x, int y)
//{
//	return x + y;
//}
//
//double add(double x, double y)
//{
//	return x + y;
//}
//
////类型顺序不同
//
//void test(int x, char y) 
//{
//	//....
//	cout << "void test(int x, char y)" << endl;
//}
//
//void test(char x, int y)
//{
//	//....
//	cout << "void test(char x, int y)" << endl;
//}
//
//
////类型个数不同
//void test1(int x)
//{
//	cout << "void test1(int a)" << endl;
//}
//
//void test1(int x, int y)
//{
//	cout << "void test1(int x, int y)" << endl;
//}


////不同命名空间，不属于重载
//namespace test2
//{
//	void t(int x, int y)
//	{
//		//....
//		cout << "void t(int x, int y)" << endl;
//	}
//}
//
//namespace test3
//{
//	void t(char x, char y)
//	{
//		//....
//		cout << "void t(char x, char y)" << endl;
//	}
//}
//
//using namespace test2;
//using namespace test3;


//返回类型不同，不能作为重载的条件
// 
//void test4(int x, int y)
//{
//	//....
//}
//
//int test4(int x, int y)
//{
//	//....
//}

//缺省参数不能作为重载的条件

////a = 10
//void test5(int a ,int b)
//{
//	//...
//}
//
////a = 50
//void test5(int a )
//{
//	//...
//}


//引用的基本使用
//int main()
//{
//
//	int a = 10;
//
//	//错误例子
//	//定义时未初始化
//
//	/*int& b;
//	b = a;*/
//
//	//正确的使用 ：定义时初始化
//	//给a取别名 ，c是a的别名
//	int& c = a;
//
//	//多次引用
//	int& d = a;
//	int& e = d;
//
//	//引用类型和实体类型不一致，会报错
//	/*double f = 1.12;
//	int& e = f;*/
//
//
//	cout << "a: " << a << endl;
//	cout << "a的地址:" << &a<<endl;
//
//	cout << "c: " << c << endl;
//	cout << "c的地址:" << &c << endl;
//
//	cout << "d: " << d << endl;
//	cout << "d的地址:" << &d << endl;
//
//	cout << "e: " << e << endl;
//	cout << "e的地址:" << &e << endl;
//
//	int g = 20;
//	//这是一个赋值，而不是重新引用
//	d = g;
//
//	//改变d ,其他别名也会跟着改变（改变一个别名或者实体其他也会跟着改变）
//	cout << "改变d后" << endl;
//	cout << "a: " << a << endl;
//	cout << "c: " << c << endl;
//	cout << "d: " << d << endl;
//	cout << "e: " << e << endl;
//
//
//	return 0;
//}


//引用做函数参数

//x是a的别名 ， y时b的别名
//void Swap(int& x, int& y)
//{
//	cout << "x: " <<x<< endl;
//	cout << "x的地址: " << &x<<endl;
//	cout << "y: " << y<<endl;
//	cout << "y的地址: " << &y<< endl;
//
//	int tmp = x;
//	x = y;
//	y = tmp;
//
//	cout << "改变后的x: " << x << endl;
//	cout << "改变后的y: " << y << endl;
//
//}
//
//int main()
//{
//
//	int a = 10;
//	int b = 20;
//
//	cout << "a: " <<a<< endl;
//	cout << "a的地址: " << &a << endl;
//	cout << "b: " <<b<< endl;
//	cout << "b的地址: " << &b << endl;
//
//	Swap(a, b);
//
//	cout << "改变后的a: " << a << endl;
//	cout << "改变后的b: " << b << endl;
//
//	return 0;
//}

//检测时间函数的头文件
//#include <time.h> 
// struct Node
//{
//	int a[10000];
//};
//
// //传值
//void test1(Node p)
//{
//	//...
//}
//
////引用
//void test2(Node & p)
//{
//	//...
//}
//
//void test3()
//{
//	Node p;
//	size_t begin1 = clock();	//开始
//	for (int i = 0; i < 100000; i++)
//	{
//
//		test1(p);
//	}
//	size_t end1 = clock();	//结束
//
//	size_t begin2 = clock();	//开始
//	for (int i = 0; i < 100000; i++)
//	{
//		test2(p);
//	}
//	size_t end2 = clock();	//结束
//
//	cout << "传值" << end1 - begin1 << endl;
//	cout << "引用" << end2 - begin2 << endl;
//}
//
//
////返回的值
//Node a;
//
////传值
//Node test4()
//{
//	return a;
//}
//
////引用
//Node& test5()
//{
//	return a;
//}
//
//void test6()
//{
//	size_t begin1 = clock();	//开始
//	for (int i = 0; i < 100000; i++)
//	{
//
//		test4();
//	}
//	size_t end1 = clock();	//结束
//
//	size_t begin2 = clock();	//开始
//	for (int i = 0; i < 100000; i++)
//	{
//		test5();
//	}
//	size_t end2 = clock();	//结束
//
//	cout << "传值" << end1 - begin1 << endl;
//	cout << "引用" << end2 - begin2 << endl;
//}
//
//int main()
//{
//	test6();
//}
//
//
//

//int & test()
//{
//	//...
//	//动态申请
//	int* a = new int;
//	*a = 10;
//	cout << a << endl;
//	return *a;
//}
//
//int main()
//{	
//	//通过引用接收
//	int &b = test();
//	cout << &b << endl;
//
//	return 0;
//}

//int main()
//{
//	const int a = 10;	//修饰为常量  a只读 
////	int& b = a;	//b可读可写   权限放大 ，错误
//	const int& b = a; //正确
//
//	int c = 10;	 //c可读可写 
//	const int & d = c;	//d只读 ，权限放小 ， 正确
//
////	int& e = 10; //e可读可写 ， 10为常量 ，只读  权限放大
//	const int& e = 10; //正确
//
//	double f = 1.1;
//	int g = f; //会发生隐式转换  g = 1 ，正确
//
//	//隐式类型转换以及表达式计算 在赋值给变量前就已经生成了一个临时变量 ，用这个临时变量在赋值 
//	//如 f赋给g ，会先生成const int tmp = 1 ,再用 g = tmp
//
////	int& h = f;//h可读可写  ，f发生隐式转换，const int tmp = 1 //tmp 只读 ，权限放大
//	const int& h = f;	//正确
//
//	int i = 10, j = 10;
////	int& k = i + j; //与上面一样 错误
//	const int& k = i + j;
//
//	return 0;
//}

//int main()
//{
//	int a = 10;
//	int& b = a;
//	int* c = &a;
//
//	return 0;
//}
//

//inline int Add(int x, int y)
//{
//	return x + y;
//}
//int main()
//{
//	Add(10, 10);
//
//	return 0;
//}


//int main()
//{
//	auto a = 10;
//	//int a = 10;
//	auto b = 'a';
//	//char b = 'a'
//
//	//typeid求类型名称
//	cout << typeid(a).name() << endl;
//	cout << typeid(b).name() << endl;
//
//	return 0;
//
//}

	//typedef char* pstring;
	//int main()
	//{	
	//	/*const pstring p1  ;
	//	const pstring* p2;*/
	//	return 0;
	//}

//int main()
//{
//	int a = 10;
//
//	auto* p1 = &a;
//	auto p2 = &a;
//
//	auto& p3 = a;
//
//	//typeid求类型名称
//	cout << typeid(p1).name() << endl;
//	cout << typeid(p2).name() << endl;
//	cout << typeid(p3).name() << endl;
//
//	return 0;
//}
//void test(auto a) //err
//{
//	//...
//}
//
//int main()
//{
//	//相同类型
//	//auto a = 10, b = 20;
//
//	auto a[100] = { 0 }; //err
//	return 0;
//}

//int main()
//{
//	//数组
//	int arr[5] = { 1,2,3,4,5 };
//
//	// 遍历过程： 将arr的元素赋值给 i ,再进行 ++ 再赋值 
//	for (auto i : arr)
//	{
//		cout << i << " ";
//	}
//	cout << endl;
//	//当我们明确类型也可以这样使用
//	for (int i : arr)
//	{
//		cout << i << " ";
//	}
//
//	return 0;
//}

//int main()
//{
//	//数组
//	int arr[5] = { 1,2,3,4,5 };
//
//	//修改
//	for (auto &i : arr)
//	{
//		i *= 2;
//	}
//
//	for (auto i : arr)
//	{
//		cout << i << " ";
//	}
//
//
//	return 0;
//}

////整形
//void test(int a)
//{
//	cout << "void test(int a)" << endl;
//}
//
////指针
//void test(int* a)
//{
//	cout << "void test(int *a)" << endl;
//}
//int main()
//{
//	test(0);
//	test(NULL);
//	test(nullptr);
//
//	return 0;
//}